// 版权归Go作者所有。版权所有。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

// 检查指针写入是否遵循cgo规则的代码。
// 当debug.cgocheck>1时，通过写屏障调用这些函数。

package runtime

import (
	"runtime/internal/sys"
	"unsafe"
)

const cgoWriteBarrierFail = "Go pointer stored into non-Go memory"

// cgoCheckWriteBarrier在指针存储到内存时调用。
// 如果程序正在将Go指针存储到非Go内存中，则抛出。
// 
// 这是从写屏障调用的，因此它的整个调用树必须是nosplit。
// 
// go:nosplit 
// go:nowritebarrier 
func cgoCheckWriteBarrier(dst *uintptr, src uintptr) {
	if !cgoIsGoPointer(unsafe.Pointer(src)) {
		return
	}
	if cgoIsGoPointer(unsafe.Pointer(dst)) {
		return
	}

	// 如果我们在系统堆栈上运行，那么dst可能是堆栈上的
	// 地址，这是可以的。
	g := getg()
	if g == g.m.g0 || g == g.m.gsignal {
		return
	}

	// 分配内存可以写入各种mfixalloc结构
	// 看起来它们是非Go内存。
	if g.m.mallocing != 0 {
		return
	}

	// 如果写入persistentalloc分配的内存，则可以。
	// 最后检查，因为它更昂贵，而且很少是真的。
	// 如果它是假的，那么费用就无关紧要了，因为我们正在崩溃。
	if inPersistentAlloc(uintptr(unsafe.Pointer(dst))) {
		return
	}

	systemstack(func() {
		println("write of Go pointer", hex(src), "to non-Go memory", hex(uintptr(unsafe.Pointer(dst))))
		throw(cgoWriteBarrierFail)
	})
}

// cgoCheckMemmove在移动内存块时被调用。
// dst和src将字节指向要复制的值。
// size是要复制的字节数。
// 如果程序正在将包含Go指针的块复制到非Go内存中，它将抛出。
// go:nosplit 
// go:nowritebarrier 
func cgoCheckMemmove(typ *_type, dst, src unsafe.Pointer, off, size uintptr) {
	if typ.ptrdata == 0 {
		return
	}
	if !cgoIsGoPointer(src) {
		return
	}
	if cgoIsGoPointer(dst) {
		return
	}
	cgoCheckTypedBlock(typ, src, off, size)
}

// cgoCheckSliceCopy在复制切片的n个元素时调用。
// src和dst是指向切片的第一个元素的指针。
// typ是切片的元素类型。
// 如果程序正在将包含Go指针的切片元素复制到非Go内存中，它将抛出。
// go:nosplit 
// go:nowritebarrier 
func cgoCheckSliceCopy(typ *_type, dst, src unsafe.Pointer, n int) {
	if typ.ptrdata == 0 {
		return
	}
	if !cgoIsGoPointer(src) {
		return
	}
	if cgoIsGoPointer(dst) {
		return
	}
	p := src
	for i := 0; i < n; i++ {
		cgoCheckTypedBlock(typ, p, 0, typ.size)
		p = add(p, typ.size)
	}
}

// cgoCheckTypedBlock检查src处的内存块，以查找最大大小的字节，
// 并在找到go指针时抛出。内存的类型是typ，
// ，src是该类型的off字节。
// go:nosplit 
// go:nowritebarrier 
func cgoCheckTypedBlock(typ *_type, src unsafe.Pointer, off, size uintptr) {
	// 任何超过typ.ptrdata的内容都不是指针。
	if typ.ptrdata <= off {
		return
	}
	if ptrdataSize := typ.ptrdata - off; size > ptrdataSize {
		size = ptrdataSize
	}

	if typ.kind&kindGCProg == 0 {
		cgoCheckBits(src, typ.gcdata, off, size)
		return
	}

	// 该类型有一个GC程序。尝试在其他地方查找GC位。
	for _, datap := range activeModules() {
		if cgoInRange(src, datap.data, datap.edata) {
			doff := uintptr(src) - datap.data
			cgoCheckBits(add(src, -doff), datap.gcdatamask.bytedata, off+doff, size)
			return
		}
		if cgoInRange(src, datap.bss, datap.ebss) {
			boff := uintptr(src) - datap.bss
			cgoCheckBits(add(src, -boff), datap.gcbssmask.bytedata, off+boff, size)
			return
		}
	}

	s := spanOfUnchecked(uintptr(src))
	if s.state.get() == mSpanManual {
		// 堆栈上存储的值没有堆位。
		// 对于通道接收，src可能位于某些
		// 其他goroutine的堆栈上，因此即使我们想要，我们也无法解除堆栈。
		// 如果没有额外的存储，我们无法扩展GC程序
		// 我们很难获得空间。
		// 幸运的是我们有类型信息。
		systemstack(func() {
			cgoCheckUsingType(typ, src, off, size)
		})
		return
	}

	// src必须在常规堆中。

	hbits := heapBitsForAddr(uintptr(src))
	for i := uintptr(0); i < off+size; i += sys.PtrSize {
		bits := hbits.bits()
		if i >= off && bits&bitPointer != 0 {
			v := *(*unsafe.Pointer)(add(src, i))
			if cgoIsGoPointer(v) {
				throw(cgoWriteBarrierFail)
			}
		}
		hbits = hbits.next()
	}
}

// cgoCheckBits检查src处的内存块大小是否达到
// 字节，如果找到Go指针，则抛出。gcbits标记每个
// 指针值。src指针关闭了gcbits中的字节。
// go:nosplit 
// go:nowritebarrier 
func cgoCheckBits(src unsafe.Pointer, gcbits *byte, off, size uintptr) {
	skipMask := off / sys.PtrSize / 8
	skipBytes := skipMask * sys.PtrSize * 8
	ptrmask := addb(gcbits, skipMask)
	src = add(src, skipBytes)
	off -= skipBytes
	size += off
	var bits uint32
	for i := uintptr(0); i < size; i += sys.PtrSize {
		if i&(sys.PtrSize*8-1) == 0 {
			bits = uint32(*ptrmask)
			ptrmask = addb(ptrmask, 1)
		} else {
			bits >>= 1
		}
		if off > 0 {
			off -= sys.PtrSize
		} else {
			if bits&1 != 0 {
				v := *(*unsafe.Pointer)(add(src, i))
				if cgoIsGoPointer(v) {
					throw(cgoWriteBarrierFail)
				}
			}
		}
	}
}

// cgoCheckUsingType类似于cgoCheckTypedBlock，但它是最后的选择
// 使用类型信息在src中查找指针。
// 当类型
// 使用GC程序时，我们仅在查看堆栈上的值时使用此选项，因为否则使用
// GC位更有效。这是在系统堆栈上调用的。
// go:nowritebarrier 
// go:systemstack 
func cgoCheckUsingType(typ *_type, src unsafe.Pointer, off, size uintptr) {
	if typ.ptrdata == 0 {
		return
	}

	// 任何超过typ.ptrdata的内容都不是指针。
	if typ.ptrdata <= off {
		return
	}
	if ptrdataSize := typ.ptrdata - off; size > ptrdataSize {
		size = ptrdataSize
	}

	if typ.kind&kindGCProg == 0 {
		cgoCheckBits(src, typ.gcdata, off, size)
		return
	}
	switch typ.kind & kindMask {
	default:
		throw("can't happen")
	case kindArray:
		at := (*arraytype)(unsafe.Pointer(typ))
		for i := uintptr(0); i < at.len; i++ {
			if off < at.elem.size {
				cgoCheckUsingType(at.elem, src, off, size)
			}
			src = add(src, at.elem.size)
			skipped := off
			if skipped > at.elem.size {
				skipped = at.elem.size
			}
			checked := at.elem.size - skipped
			off -= skipped
			if size <= checked {
				return
			}
			size -= checked
		}
	case kindStruct:
		st := (*structtype)(unsafe.Pointer(typ))
		for _, f := range st.fields {
			if off < f.typ.size {
				cgoCheckUsingType(f.typ, src, off, size)
			}
			src = add(src, f.typ.size)
			skipped := off
			if skipped > f.typ.size {
				skipped = f.typ.size
			}
			checked := f.typ.size - skipped
			off -= skipped
			if size <= checked {
				return
			}
			size -= checked
		}
	}
}
